package com.estore.service;

import com.estore.model.Product;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.Properties;  // 新增import

/**
 * 商品服务类，负责商品相关的业务逻辑
 */
public class ProductService {

    // 使用Map存储商品数据，key是商品ID，value是商品对象
    private Map<String, Product> productData = new HashMap<>(); // 移除了final，因为需要重新赋值
    private String dataFilePath; // 从配置文件读取的路径

    /**
     * 构造函数，初始化商品数据
     */
    public ProductService() {
        loadConfig(); // 先加载配置
        loadData();   // 再加载数据
    }

    /**
     * 加载配置文件
     */
    private void loadConfig() {
        Properties props = new Properties();
        File configFile = new File("config.properties");

        if (!configFile.exists()) {
            // 如果配置文件不存在，使用默认值
            dataFilePath = "products.dat";
            System.out.println("📝 配置文件不存在，使用默认路径: " + dataFilePath);
            return;
        }

        try (InputStreamReader reader = new InputStreamReader(
                new FileInputStream("config.properties"), "UTF-8")) {
            props.load(reader);
            dataFilePath = props.getProperty("data.file.path", "products.dat");
            System.out.println("✅ 配置文件加载成功，数据文件路径: " + dataFilePath);
        } catch (IOException e) {
            System.out.println("❌ 加载配置文件失败: " + e.getMessage());
            dataFilePath = "products.dat"; // 使用默认值
        }
    }

    /**
     * 保存数据到文件
     */
    public void saveData() {
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(dataFilePath))) {
            oos.writeObject(productData);
            System.out.println("✅ 商品数据已保存到: " + dataFilePath);
        } catch (IOException e) {
            System.out.println("❌ 保存数据失败: " + e.getMessage());
        }
    }

    /**
     * 从文件加载数据
     */
    @SuppressWarnings("unchecked")
    public void loadData() {
        File file = new File(dataFilePath);
        if (!file.exists()) {
            System.out.println("📝 数据文件不存在，初始化默认商品数据");
            initializeDefaultProducts();
            return;
        }

        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(dataFilePath))) {
            productData = (Map<String, Product>) ois.readObject();
            System.out.println("✅ 商品数据已从文件加载: " + dataFilePath);
            System.out.println("📊 当前商品数量: " + productData.size());
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("❌ 加载数据失败: " + e.getMessage());
            System.out.println("📝 使用默认商品数据");
            initializeDefaultProducts();
        }
    }

    /**
     * 初始化默认商品数据
     */
    private void initializeDefaultProducts() {
        productData.put("p001", new Product("p001", "Java从入门到精通", 99.0, 100));
        productData.put("p002", new Product("p002", "高性能MySQL", 128.5, 50));
        productData.put("p003", new Product("p003", "颈椎康复指南", 45.0, 200));
        productData.put("p004", new Product("p004", "生发秘籍", 88.0, 0));
    }

    // ========== 以下是原有的业务方法，保持不变 ==========

    /**
     * 获取所有商品列表
     */
    public List<Product> getAllProducts() {
        return new ArrayList<>(productData.values());
    }

    /**
     * 根据ID查找商品
     */
    public Product findProductById(String id) {
        return productData.get(id);
    }

    /**
     * 添加新商品
     */
    public boolean addProduct(Product product) {
        if (product == null || product.getId() == null || productData.containsKey(product.getId())) {
            return false;
        }
        productData.put(product.getId(), product);
        saveData(); // 添加商品后自动保存
        return true;
    }

    /**
     * 更新商品信息
     */
    public boolean updateProduct(Product product) {
        if (product == null || product.getId() == null || !productData.containsKey(product.getId())) {
            return false;
        }
        productData.put(product.getId(), product);
        saveData(); // 更新商品后自动保存
        return true;
    }

    /**
     * 删除商品
     */
    public boolean deleteProduct(String id) {
        if (id == null || !productData.containsKey(id)) {
            return false;
        }
        productData.remove(id);
        saveData(); // 删除商品后自动保存
        return true;
    }

    /**
     * 减少商品库存（用于下单时）
     */
    public boolean decreaseProductStock(String id, int quantity) {
        if (quantity <= 0) {
            return false;
        }

        Product product = findProductById(id);
        if (product == null || product.getStock() < quantity) {
            return false;
        }

        product.setStock(product.getStock() - quantity);
        saveData(); // 库存变化后自动保存
        return true;
    }

    /**
     * 增加商品库存
     */
    public boolean increaseProductStock(String id, int quantity) {
        if (quantity <= 0) {
            return false;
        }

        Product product = findProductById(id);
        if (product == null) {
            return false;
        }

        product.setStock(product.getStock() + quantity);
        saveData(); // 库存变化后自动保存
        return true;
    }

    // ========== 其他原有方法保持不变 ==========

    /**
     * 根据商品名称模糊搜索商品
     */
    public List<Product> searchProductsByName(String name) {
        if (name == null || name.trim().isEmpty()) {
            return new ArrayList<>();
        }

        String searchKey = name.toLowerCase();
        return productData.values().stream()
                .filter(product -> product.getName().toLowerCase().contains(searchKey))
                .collect(Collectors.toList());
    }

    /**
     * 获取有库存的商品列表
     */
    public List<Product> getAvailableProducts() {
        return productData.values().stream()
                .filter(product -> product.getStock() > 0)
                .collect(Collectors.toList());
    }

    /**
     * 获取缺货商品列表
     */
    public List<Product> getOutOfStockProducts() {
        return productData.values().stream()
                .filter(product -> product.getStock() == 0)
                .collect(Collectors.toList());
    }

    /**
     * 根据价格范围筛选商品
     */
    public List<Product> getProductsByPriceRange(double minPrice, double maxPrice) {
        if (minPrice < 0 || maxPrice < minPrice) {
            return new ArrayList<>();
        }

        return productData.values().stream()
                .filter(product -> product.getPrice() >= minPrice && product.getPrice() <= maxPrice)
                .collect(Collectors.toList());
    }

    /**
     * 更新商品库存
     */
    public boolean updateProductStock(String id, int newStock) {
        if (newStock < 0) {
            return false;
        }

        Product product = findProductById(id);
        if (product == null) {
            return false;
        }

        product.setStock(newStock);
        saveData(); // 库存变化后自动保存
        return true;
    }

    /**
     * 获取商品总数
     */
    public int getTotalProductCount() {
        return productData.size();
    }

    /**
     * 检查商品是否存在
     */
    public boolean productExists(String id) {
        return productData.containsKey(id);
    }

    /**
     * 检查商品是否有足够库存
     */
    public boolean isStockSufficient(String id, int requiredQuantity) {
        Product product = findProductById(id);
        return product != null && product.getStock() >= requiredQuantity;
    }

    /**
     * 获取所有商品的总价值
     */
    public double getTotalProductsValue() {
        return productData.values().stream()
                .mapToDouble(product -> product.getPrice() * product.getStock())
                .sum();
    }
}